home *** CD-ROM | disk | FTP | other *** search
/ Maclife 157 / MACLIFE157-2001-09.ISO.7z / MACLIFE157-2001-09.ISO / Linux / MacOS Tools / BootX 1.2.2 / Sources / src / miboot / nr_wrapper.c < prev    next >
C/C++ Source or Header  |  2001-07-23  |  22KB  |  633 lines
  1. #include "nr_wrapper.h"
  2. #include "debug_text.h"
  3.  
  4. #include <CodeFragments.h>
  5. #include <MixedMode.h>
  6.  
  7. enum {
  8.     kRegistryEntryIDInit,
  9.     kRegistryEntryIDCompare,
  10.     kRegistryEntryIDCopy,
  11.     kRegistryEntryIDDispose,
  12.     kRegistryCStrEntryCreate,
  13.     kRegistryEntryDelete,
  14.     kRegistryEntryCopy,
  15.     kRegistryEntryIterateCreate,
  16.     kRegistryEntryIterateDispose,
  17.     kRegistryEntryIterateSet,
  18.     kRegistryEntryIterate,
  19.     kRegistryEntrySearch,
  20.     kRegistryCStrEntryLookup,
  21.     kRegistryEntryToPathSize,
  22.     kRegistryCStrEntryToPath,
  23.     kRegistryCStrEntryToName,
  24.     kRegistryPropertyCreate,
  25.     kRegistryPropertyDelete,
  26.     kRegistryPropertyRename,
  27.     kRegistryPropertyIterateCreate,
  28.     kRegistryPropertyIterateDispose,
  29.     kRegistryPropertyIterate,
  30.     kRegistryPropertyGetSize,
  31.     kRegistryPropertyGet,
  32.     kRegistryPropertySet,
  33.     kRegistryEntryGetMod,
  34.     kRegistryEntrySetMod,
  35.     kRegistryPropertyGetMod,
  36.     kRegistryPropertySetMod,
  37.     kRegistryEntryMod,
  38.     kRegistryEntryPropertyMod,
  39.     
  40.     kRegistryCount
  41. };
  42.  
  43. static UniversalProcPtr        __nr_symbols[kRegistryCount];
  44. static CFragConnectionID    __nr_connID;
  45.  
  46. extern dt_context*    dct;
  47.  
  48.  
  49. OSStatus
  50. init_nr_wrappers()
  51. {
  52.     OSStatus                err;
  53.     Ptr                        mainAddr;
  54.     Str255                     errMessage;
  55.     CFragSymbolClass        symClass;
  56.     Ptr                        symbol;
  57.     
  58.     err = GetSharedLibrary(    "¥pNameRegistryLib",
  59.                             kPowerPCCFragArch,
  60.                             kReferenceCFrag,
  61.                             &__nr_connID,
  62.                             &mainAddr,
  63.                             errMessage);
  64.     if (err != noErr) {
  65.         dt_printf(dct, "GetSharedLibrary() failed <%#s>¥n", errMessage);
  66.         return err;
  67.     }
  68.     
  69. #define LOOKUP_SYMBOL(name, procInfo)    ¥
  70.         err = FindSymbol(__nr_connID, "¥p" #name, &symbol,&symClass);    ¥
  71.         if (err == noErr)    {¥
  72.             __nr_symbols[k##name] = NewRoutineDescriptorTrap(    ¥
  73.                 (ProcPtr)symbol, procInfo, kPowerPCISA);    ¥
  74.         } else {¥
  75.             __nr_symbols[k##name] = NULL; ¥
  76.         }
  77.             
  78.     LOOKUP_SYMBOL(RegistryEntryIDInit, kCStackBased
  79.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  80.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  81.     )
  82.     LOOKUP_SYMBOL(RegistryEntryIDCompare, kCStackBased
  83.          | RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
  84.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  85.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryID *)))
  86.     )
  87.     LOOKUP_SYMBOL(RegistryEntryIDCopy, kCStackBased
  88.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  89.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  90.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryID *)))
  91.     )
  92.     LOOKUP_SYMBOL(RegistryEntryIDDispose, kCStackBased
  93.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  94.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  95.     )
  96.     LOOKUP_SYMBOL(RegistryCStrEntryCreate, kCStackBased
  97.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  98.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  99.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegCStrPathName *)))
  100.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  101.     )
  102.     LOOKUP_SYMBOL(RegistryEntryDelete, kCStackBased
  103.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  104.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  105.     )
  106.     LOOKUP_SYMBOL(RegistryEntryCopy, kCStackBased
  107.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  108.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  109.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryID *)))
  110.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  111.     )
  112.     LOOKUP_SYMBOL(RegistryEntryIterateCreate, kCStackBased
  113.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  114.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  115.     )
  116.     LOOKUP_SYMBOL(RegistryEntryIterateDispose, kCStackBased
  117.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  118.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  119.     )
  120.     LOOKUP_SYMBOL(RegistryEntryIterateSet, kCStackBased
  121.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  122.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  123.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryID *)))
  124.     )
  125.     LOOKUP_SYMBOL(RegistryEntryIterate, kCStackBased
  126.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  127.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  128.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryIterationOp)))
  129.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  130.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Boolean *)))
  131.     )
  132.     LOOKUP_SYMBOL(RegistryEntrySearch, kCStackBased
  133.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  134.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  135.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryIterationOp)))
  136.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  137.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Boolean *)))
  138.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(RegPropertyName *)))
  139.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(void *)))
  140.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(RegPropertyValueSize)))
  141.     )
  142.     LOOKUP_SYMBOL(RegistryCStrEntryLookup, kCStackBased
  143.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  144.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  145.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegCStrPathName *)))
  146.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  147.     )
  148.     LOOKUP_SYMBOL(RegistryEntryToPathSize, kCStackBased
  149.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  150.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  151.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPathNameSize *)))
  152.     )
  153.     LOOKUP_SYMBOL(RegistryCStrEntryToPath, kCStackBased
  154.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  155.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  156.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegCStrPathName *)))
  157.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegPathNameSize)))
  158.     )
  159.     LOOKUP_SYMBOL(RegistryCStrEntryToName, kCStackBased
  160.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  161.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  162.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryID *)))
  163.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegCStrEntryName *)))
  164.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Boolean *)))
  165.     )
  166.     LOOKUP_SYMBOL(RegistryPropertyCreate, kCStackBased
  167.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  168.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  169.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  170.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  171.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RegPropertyValueSize)))
  172.     )
  173.     LOOKUP_SYMBOL(RegistryPropertyDelete, kCStackBased
  174.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  175.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  176.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  177.     )
  178.     LOOKUP_SYMBOL(RegistryPropertyRename, kCStackBased
  179.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  180.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  181.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  182.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegPropertyName *)))
  183.     )
  184.     LOOKUP_SYMBOL(RegistryPropertyIterateCreate, kCStackBased
  185.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  186.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  187.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyIter *)))
  188.     )
  189.     LOOKUP_SYMBOL(RegistryPropertyIterateDispose, kCStackBased
  190.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  191.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegPropertyIter *)))
  192.     )
  193.     LOOKUP_SYMBOL(RegistryPropertyIterate, kCStackBased
  194.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  195.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegPropertyIter *)))
  196.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  197.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean *)))
  198.     )
  199.     LOOKUP_SYMBOL(RegistryPropertyGetSize, kCStackBased
  200.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  201.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  202.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  203.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegPropertyValueSize *)))
  204.     )
  205.     LOOKUP_SYMBOL(RegistryPropertyGet, kCStackBased
  206.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  207.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  208.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  209.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  210.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RegPropertyValueSize *)))
  211.     )
  212.     LOOKUP_SYMBOL(RegistryPropertySet, kCStackBased
  213.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  214.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  215.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  216.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  217.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RegPropertyValueSize)))
  218.     )
  219.     LOOKUP_SYMBOL(RegistryEntryGetMod, kCStackBased
  220.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  221.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  222.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryModifiers *)))
  223.     )
  224.     LOOKUP_SYMBOL(RegistryEntrySetMod, kCStackBased
  225.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  226.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  227.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryModifiers)))
  228.     )
  229.     LOOKUP_SYMBOL(RegistryPropertyGetMod, kCStackBased
  230.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  231.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  232.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  233.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegPropertyModifiers *)))
  234.     )
  235.     LOOKUP_SYMBOL(RegistryPropertySetMod, kCStackBased
  236.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  237.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryID *)))
  238.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegPropertyName *)))
  239.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegPropertyModifiers)))
  240.     )
  241.     LOOKUP_SYMBOL(RegistryEntryMod, kCStackBased
  242.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  243.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  244.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryIterationOp)))
  245.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  246.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Boolean *)))
  247.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(RegEntryModifiers)))
  248.     )
  249.     LOOKUP_SYMBOL(RegistryEntryPropertyMod, kCStackBased
  250.          | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  251.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(RegEntryIter *)))
  252.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RegEntryIterationOp)))
  253.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegEntryID *)))
  254.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Boolean *)))
  255.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(RegEntryModifiers)))
  256.     )
  257.     
  258.     return noErr;
  259. }
  260.  
  261. OSStatus
  262. dispose_nr_wrappers(void)
  263. {
  264.     int i;
  265.     
  266.     for(i=0; i<kRegistryCount; i++) {
  267.         if (__nr_symbols[i]) {
  268.             DisposeRoutineDescriptorTrap(__nr_symbols[i]);
  269.             __nr_symbols[i] = NULL;
  270.         }
  271.     }
  272.     CloseConnection(&__nr_connID);
  273. }
  274.  
  275.  
  276. OSStatus
  277. RegistryEntryIDInit                (RegEntryID *            id)
  278. {
  279.     if (__nr_symbols[kRegistryEntryIDInit] == NULL)
  280.         return -1;
  281.     return ((OSStatus (*)(RegEntryID *))(__nr_symbols[kRegistryEntryIDInit]))(id);
  282. }
  283.  
  284. Boolean
  285. RegistryEntryIDCompare            (const RegEntryID *        id1,
  286.                                  const RegEntryID *        id2)
  287. {
  288.     if (__nr_symbols[kRegistryEntryIDCompare] == NULL)
  289.         return false;
  290.     return ((OSStatus (*)(const RegEntryID *, const RegEntryID *))
  291.         (__nr_symbols[kRegistryEntryIDCompare]))(id1, id2);
  292. }
  293.  
  294. OSStatus
  295. RegistryEntryIDCopy                (const RegEntryID *        src,
  296.                                  RegEntryID *            dst)
  297. {
  298.     if (__nr_symbols[kRegistryEntryIDCopy] == NULL)
  299.         return -1;
  300.     return ((OSStatus (*)(const RegEntryID *,RegEntryID *))
  301.         (__nr_symbols[kRegistryEntryIDCopy]))(src,dst);
  302. }
  303.  
  304. OSStatus
  305. RegistryEntryIDDispose            (RegEntryID *            id)
  306. {
  307.     if (__nr_symbols[kRegistryEntryIDDispose] == NULL)
  308.         return -1;
  309.     return ((OSStatus (*)(RegEntryID *))(__nr_symbols[kRegistryEntryIDDispose]))(id);
  310. }
  311.  
  312. OSStatus
  313. RegistryCStrEntryCreate            (const RegEntryID *        parentEntry,
  314.                                  const RegCStrPathName * name,
  315.                                  RegEntryID *            newEntry)
  316. {
  317.     if (__nr_symbols[kRegistryCStrEntryCreate] == NULL)
  318.         return -1;
  319.     return ((OSStatus (*)(const RegEntryID *,const RegCStrPathName *,RegEntryID *))
  320.         (__nr_symbols[kRegistryCStrEntryCreate]))(parentEntry,name,newEntry);
  321. }                                 
  322.  
  323. OSStatus
  324. RegistryEntryDelete                (const RegEntryID *        id)
  325. {
  326.     if (__nr_symbols[kRegistryEntryDelete] == NULL)
  327.         return -1;
  328.     return ((OSStatus (*)(const RegEntryID *))(__nr_symbols[kRegistryEntryDelete]))(id);
  329. }
  330.  
  331. OSStatus
  332. RegistryEntryCopy                (RegEntryID *            parentEntryID,
  333.                                  RegEntryID *            sourceDevice,
  334.                                  RegEntryID *            destDevice)
  335. {
  336.     if (__nr_symbols[kRegistryEntryCopy] == NULL)
  337.         return -1;
  338.     return ((OSStatus (*)(RegEntryID *,RegEntryID *,RegEntryID *))
  339.         (__nr_symbols[kRegistryEntryCopy]))(parentEntryID,sourceDevice,destDevice);
  340. }
  341.  
  342. OSStatus
  343. RegistryEntryIterateCreate        (RegEntryIter *            cookie)
  344. {
  345.     if (__nr_symbols[kRegistryEntryIterateCreate] == NULL)
  346.         return -1;
  347.     return ((OSStatus (*)(RegEntryIter *))(__nr_symbols[kRegistryEntryIterateCreate]))(cookie);
  348. }
  349.  
  350. OSStatus
  351. RegistryEntryIterateDispose        (RegEntryIter *            cookie)
  352. {
  353.     if (__nr_symbols[kRegistryEntryIterateDispose] == NULL)
  354.         return -1;
  355.     return ((OSStatus (*)(RegEntryIter *))(__nr_symbols[kRegistryEntryIterateDispose]))(cookie);
  356. }
  357.  
  358. OSStatus
  359. RegistryEntryIterateSet            (RegEntryIter *            cookie,
  360.                                  const RegEntryID *        startEntryID)
  361. {
  362.     if (__nr_symbols[kRegistryEntryIterateSet] == NULL)
  363.         return -1;
  364.     return ((OSStatus (*)(RegEntryIter*,const RegEntryID*))
  365.         (__nr_symbols[kRegistryEntryIterateSet]))
  366.         (cookie, startEntryID);
  367. }
  368.  
  369. OSStatus
  370. RegistryEntryIterate            (RegEntryIter *            cookie,
  371.                                  RegEntryIterationOp     relationship,
  372.                                  RegEntryID *            foundEntry,
  373.                                  Boolean *                done)
  374. {
  375.     if (__nr_symbols[kRegistryEntryIterate] == NULL)
  376.         return -1;
  377.     return ((OSStatus (*)(RegEntryIter*,RegEntryIterationOp,RegEntryID*,Boolean*))
  378.         (__nr_symbols[kRegistryEntryIterate]))
  379.         (cookie, relationship, foundEntry, done);
  380. }
  381.  
  382. OSStatus
  383. RegistryEntrySearch                (RegEntryIter *            cookie,
  384.                                  RegEntryIterationOp     relationship,
  385.                                  RegEntryID *            foundEntry,
  386.                                  Boolean *                done,
  387.                                  const RegPropertyName * propertyName,
  388.                                  const void *            propertyValue,
  389.                                  RegPropertyValueSize     propertySize)
  390. {
  391.     if (__nr_symbols[kRegistryEntrySearch] == NULL)
  392.         return -1;
  393.     return ((OSStatus (*)(RegEntryIter*,RegEntryIterationOp,RegEntryID*,Boolean*,
  394.         const RegPropertyName*,const void*,RegPropertyValueSize))
  395.         (__nr_symbols[kRegistryEntrySearch]))
  396.         (cookie,relationship,foundEntry,done,propertyName,propertyValue,propertySize);
  397. }
  398.  
  399. OSStatus
  400. RegistryCStrEntryLookup            (const RegEntryID *        searchPointID,
  401.                                  const RegCStrPathName * pathName,
  402.                                  RegEntryID *            foundEntry)
  403. {
  404.     if (__nr_symbols[kRegistryCStrEntryLookup] == NULL)
  405.         return -1;
  406.     return ((OSStatus (*)(const RegEntryID*,const RegCStrPathName*,RegEntryID*))
  407.         (__nr_symbols[kRegistryCStrEntryLookup]))
  408.         (searchPointID,pathName,foundEntry);
  409. }
  410.  
  411. OSStatus
  412. RegistryEntryToPathSize            (const RegEntryID *        entryID,
  413.                                  RegPathNameSize *        pathSize)
  414. {
  415.     if (__nr_symbols[kRegistryEntryToPathSize] == NULL)
  416.         return -1;
  417.     return ((OSStatus (*)(const RegEntryID*,RegPathNameSize*))
  418.         (__nr_symbols[kRegistryEntryToPathSize]))
  419.         (entryID,pathSize);
  420. }
  421.  
  422. OSStatus
  423. RegistryCStrEntryToPath            (const RegEntryID *        entryID,
  424.                                  RegCStrPathName *        pathName,
  425.                                  RegPathNameSize         pathSize)
  426. {
  427.     if (__nr_symbols[kRegistryCStrEntryToPath] == NULL)
  428.         return -1;
  429.     return ((OSStatus (*)(const RegEntryID*,RegCStrPathName*,RegPathNameSize))
  430.         (__nr_symbols[kRegistryCStrEntryToPath]))
  431.         (entryID,pathName,pathSize);
  432. }
  433.  
  434. OSStatus
  435. RegistryCStrEntryToName            (const RegEntryID *        entryID,
  436.                                  RegEntryID *            parentEntry,
  437.                                  RegCStrEntryName *        nameComponent,
  438.                                  Boolean *                done)
  439. {
  440.     if (__nr_symbols[kRegistryCStrEntryToName] == NULL)
  441.         return -1;
  442.     return ((OSStatus (*)(const RegEntryID*,RegEntryID*,RegCStrEntryName*,Boolean*))
  443.         (__nr_symbols[kRegistryCStrEntryToName]))
  444.         (entryID,parentEntry,nameComponent,done);
  445. }
  446.  
  447. OSStatus
  448. RegistryPropertyCreate            (const RegEntryID *        entryID,
  449.                                  const RegPropertyName * propertyName,
  450.                                  const void *            propertyValue,
  451.                                  RegPropertyValueSize     propertySize)
  452. {
  453.     if (__nr_symbols[kRegistryPropertyCreate] == NULL)
  454.         return -1;
  455.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,const void*,
  456.         RegPropertyValueSize))
  457.         (__nr_symbols[kRegistryPropertyCreate]))
  458.         (entryID,propertyName,propertyValue,propertySize);
  459. }
  460.  
  461. OSStatus
  462. RegistryPropertyDelete            (const RegEntryID *        entryID,
  463.                                  const RegPropertyName * propertyName)
  464. {
  465.     if (__nr_symbols[kRegistryPropertyDelete] == NULL)
  466.         return -1;
  467.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*))
  468.         (__nr_symbols[kRegistryPropertyDelete]))
  469.         (entryID,propertyName);
  470. }
  471.  
  472. OSStatus
  473. RegistryPropertyRename            (const RegEntryID *        entry,
  474.                                  const RegPropertyName * oldName,
  475.                                  const RegPropertyName * newName)
  476. {
  477.     if (__nr_symbols[kRegistryPropertyRename] == NULL)
  478.         return -1;
  479.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,const RegPropertyName*))
  480.         (__nr_symbols[kRegistryPropertyRename]))
  481.         (entry,oldName,newName);
  482. }
  483.  
  484. OSStatus
  485. RegistryPropertyIterateCreate    (const RegEntryID *        entry,
  486.                                  RegPropertyIter *        cookie)
  487. {
  488.     if (__nr_symbols[kRegistryPropertyIterateCreate] == NULL)
  489.         return -1;
  490.     return ((OSStatus (*)(const RegEntryID*,RegPropertyIter*))
  491.         (__nr_symbols[kRegistryPropertyIterateCreate]))
  492.         (entry,cookie);
  493. }
  494.                                  
  495. OSStatus
  496. RegistryPropertyIterateDispose    (RegPropertyIter *        cookie)
  497. {
  498.     if (__nr_symbols[kRegistryPropertyIterateDispose] == NULL)
  499.         return -1;
  500.     return ((OSStatus (*)(RegPropertyIter*))
  501.         (__nr_symbols[kRegistryPropertyIterateDispose]))
  502.         (cookie);
  503. }
  504.  
  505. OSStatus
  506. RegistryPropertyIterate            (RegPropertyIter *        cookie,
  507.                                  RegPropertyName *        foundProperty,
  508.                                  Boolean *                done)
  509. {
  510.     if (__nr_symbols[kRegistryPropertyIterate] == NULL)
  511.         return -1;
  512.     return ((OSStatus (*)(RegPropertyIter*,RegPropertyName*,Boolean*))
  513.         (__nr_symbols[kRegistryPropertyIterate]))
  514.         (cookie,foundProperty,done);
  515. }
  516.  
  517. OSStatus
  518. RegistryPropertyGetSize            (const RegEntryID *        entryID,
  519.                                  const RegPropertyName * propertyName,
  520.                                  RegPropertyValueSize *    propertySize)
  521. {
  522.     if (__nr_symbols[kRegistryPropertyGetSize] == NULL)
  523.         return -1;
  524.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,RegPropertyValueSize*))
  525.         (__nr_symbols[kRegistryPropertyGetSize]))
  526.         (entryID,propertyName,propertySize);
  527. }
  528.  
  529. OSStatus
  530. RegistryPropertyGet                (const RegEntryID *        entryID,
  531.                                  const RegPropertyName * propertyName,
  532.                                  void *                    propertyValue,
  533.                                  RegPropertyValueSize *    propertySize)
  534. {
  535.     if (__nr_symbols[kRegistryPropertyGet] == NULL)
  536.         return -1;
  537.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,void*,RegPropertyValueSize*))
  538.         (__nr_symbols[kRegistryPropertyGet]))
  539.         (entryID,propertyName,propertyValue,propertySize);
  540. }
  541.  
  542. OSStatus
  543. RegistryPropertySet                (const RegEntryID *        entryID,
  544.                                  const RegPropertyName * propertyName,
  545.                                  const void *            propertyValue,
  546.                                  RegPropertyValueSize     propertySize)
  547. {
  548.     if (__nr_symbols[kRegistryPropertySet] == NULL)
  549.         return -1;
  550.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,const void*,RegPropertyValueSize))
  551.         (__nr_symbols[kRegistryPropertySet]))
  552.         (entryID,propertyName,propertyValue,propertySize);
  553. }
  554.  
  555. OSStatus
  556. RegistryEntryGetMod                (const RegEntryID *        entry,
  557.                                  RegEntryModifiers *    modifiers)
  558. {
  559.     if (__nr_symbols[kRegistryEntryGetMod] == NULL)
  560.         return -1;
  561.     return ((OSStatus (*)(const RegEntryID*,RegEntryModifiers *))
  562.         (__nr_symbols[kRegistryEntryGetMod]))
  563.         (entry,modifiers);
  564. }
  565.  
  566. OSStatus
  567. RegistryEntrySetMod                (const RegEntryID *        entry,
  568.                                  RegEntryModifiers         modifiers)
  569. {
  570.     if (__nr_symbols[kRegistryEntrySetMod] == NULL)
  571.         return -1;
  572.     return ((OSStatus (*)(const RegEntryID*,RegEntryModifiers))
  573.         (__nr_symbols[kRegistryEntrySetMod]))
  574.         (entry,modifiers);
  575. }                                 
  576.  
  577. OSStatus
  578. RegistryPropertyGetMod            (const RegEntryID *        entry,
  579.                                  const RegPropertyName * name,
  580.                                  RegPropertyModifiers *    modifiers)
  581. {
  582.     if (__nr_symbols[kRegistryPropertyGetMod] == NULL)
  583.         return -1;
  584.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,RegPropertyModifiers*))
  585.         (__nr_symbols[kRegistryPropertyGetMod]))
  586.         (entry,name,modifiers);
  587. }                                 
  588.  
  589. OSStatus
  590. RegistryPropertySetMod            (const RegEntryID *        entry,
  591.                                  const RegPropertyName * name,
  592.                                  RegPropertyModifiers     modifiers)
  593. {
  594.     if (__nr_symbols[kRegistryPropertySetMod] == NULL)
  595.         return -1;
  596.     return ((OSStatus (*)(const RegEntryID*,const RegPropertyName*,RegPropertyModifiers))
  597.         (__nr_symbols[kRegistryPropertySetMod]))
  598.         (entry,name,modifiers);
  599. }                                 
  600.  
  601.  
  602. OSStatus
  603. RegistryEntryMod                (RegEntryIter *            cookie,
  604.                                  RegEntryIterationOp     relationship,
  605.                                  RegEntryID *            foundEntry,
  606.                                  Boolean *                done,
  607.                                  RegEntryModifiers         matchingModifiers)
  608. {
  609.     if (__nr_symbols[kRegistryEntryMod] == NULL)
  610.         return -1;
  611.     return ((OSStatus (*)(RegEntryIter*,RegEntryIterationOp,RegEntryID*,
  612.         Boolean*,RegEntryModifiers))
  613.         (__nr_symbols[kRegistryEntryMod]))
  614.         (cookie, relationship, foundEntry, done, matchingModifiers);
  615. }
  616.  
  617. OSStatus
  618. RegistryEntryPropertyMod        (RegEntryIter *            cookie,
  619.                                  RegEntryIterationOp     relationship,
  620.                                  RegEntryID *            foundEntry,
  621.                                  Boolean *                done,
  622.                                  RegPropertyModifiers     matchingModifiers)
  623. {
  624.     if (__nr_symbols[kRegistryEntryPropertyMod] == NULL)
  625.         return -1;
  626.     return ((OSStatus (*)(RegEntryIter*,RegEntryIterationOp,RegEntryID*,
  627.         Boolean*,RegEntryModifiers))
  628.         (__nr_symbols[kRegistryEntryPropertyMod]))
  629.         (cookie, relationship, foundEntry, done, matchingModifiers);
  630. }
  631.                                  
  632.  
  633.